package com.scau.RBAC.service.factory;

import com.scau.RBAC.service.ExternalAuthService;
import com.scau.RBAC.service.impl.LDAPAuthAdapter;
import com.scau.RBAC.service.impl.OAuthAuthAdapter;
import com.scau.RBAC.service.impl.LocalAuthServiceImpl;
import com.scau.RBAC.exception.BusinessException;
import com.scau.RBAC.exception.ErrorCode;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 认证适配器工厂，用于创建和管理不同类型的认证适配器
 */
public class AuthAdapterFactory {
    private static final Logger logger = LoggerFactory.getLogger(AuthAdapterFactory.class);
    private static final Map<String, ExternalAuthService> adapters = new HashMap<>();
    private static ExternalAuthService defaultAdapter;
    private static final AuthAdapterFactory instance = new AuthAdapterFactory();

    private AuthAdapterFactory() {
        // 初始化所有适配器
        initAdapters();
    }

    /**
     * 获取工厂单例
     */
    public static AuthAdapterFactory getInstance() {
        return instance;
    }

    /**
     * 初始化所有适配器
     */
    private void initAdapters() {
        try {
            // 创建LDAP适配器
            LDAPAuthAdapter ldapAdapter = new LDAPAuthAdapter();
            adapters.put("LDAP", ldapAdapter);

            // 创建OAuth适配器
            OAuthAuthAdapter oauthAdapter = new OAuthAuthAdapter();
            adapters.put("OAUTH", oauthAdapter);

            // 创建本地认证服务作为默认适配器
            defaultAdapter = new LocalAuthServiceImpl();

            logger.info("认证适配器初始化完成，已注册: {}", adapters.keySet());
        } catch (Exception e) {
            logger.error("认证适配器初始化失败", e);
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "认证系统初始化失败", e);
        }
    }

    /**
     * 根据类型获取认证适配器
     * @param type 适配器类型
     * @return 认证适配器
     */
    public ExternalAuthService getAdapter(String type) {
        if (type == null || type.isEmpty()) {
            logger.warn("未指定适配器类型，返回默认适配器");
            return defaultAdapter;
        }

        ExternalAuthService adapter = adapters.get(type.toUpperCase());
        if (adapter == null) {
            logger.warn("未找到适配器类型: {}，返回默认适配器", type);
            return defaultAdapter;
        }

        // 检查适配器是否可用，如果不可用则返回默认适配器（降级策略）
        if (!adapter.isAvailable()) {
            logger.warn("适配器 {} 不可用，降级到默认适配器", type);
            return defaultAdapter;
        }

        logger.info("使用认证适配器: {}", type);
        return adapter;
    }

    /**
     * 获取默认认证适配器
     */
    public ExternalAuthService getDefaultAdapter() {
        return defaultAdapter;
    }

    /**
     * 注册新的认证适配器
     * @param type 适配器类型
     * @param adapter 适配器实例
     */
    public void registerAdapter(String type, ExternalAuthService adapter) {
        if (type == null || type.isEmpty() || adapter == null) {
            logger.warn("适配器注册失败：参数无效");
            return;
        }

        adapters.put(type.toUpperCase(), adapter);
        logger.info("成功注册新的认证适配器: {}", type);
    }

    /**
     * 设置默认适配器
     * @param adapter 默认适配器实例
     */
    public void setDefaultAdapter(ExternalAuthService adapter) {
        if (adapter != null) {
            defaultAdapter = adapter;
            logger.info("更新默认认证适配器");
        }
    }

    /**
     * 检查适配器是否存在
     * @param type 适配器类型
     */
    public boolean hasAdapter(String type) {
        return type != null && adapters.containsKey(type.toUpperCase());
    }

    /**
     * 获取所有可用的适配器类型
     */
    public String[] getAvailableAdapterTypes() {
        return adapters.keySet().toArray(new String[0]);
    }
}
